home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / ingres04.lzh / source / dbu / rmqm.c < prev    next >
Encoding:
C/C++ Source or Header  |  1985-02-08  |  15.9 KB  |  750 lines
  1. # include    <pv.h>
  2. # include    <ingres.h>
  3. # include    <access.h>
  4. # include    <aux.h>
  5. # include    <catalog.h>
  6. # include    <symbol.h>
  7. # include    <func.h>
  8. # include    <sccs.h>
  9. # include    <errors.h>
  10.  
  11. SCCSID(@(#)rmqm.c    8.3    2/8/85)
  12.  
  13. /*
  14. **  RMQM -- DBU to delete protection and integrity constraints
  15. **
  16. **    Trace Flags:
  17. **        43
  18. */
  19.  
  20.  
  21. extern    short    tTdbu[];
  22. extern    int    dest_const();
  23. extern    int    null_fn();
  24.  
  25. struct fn_def RmqmFn =
  26. {
  27.     "RMQM",
  28.     dest_const,
  29.     null_fn,
  30.     null_fn,
  31.     NULL,
  32.     0,
  33.     tTdbu,
  34.     100,
  35.     'Z',
  36.     0
  37. };
  38. /*
  39. **  DEST_CONST -- destroy constraints
  40. **
  41. **    Parameters:
  42. **        pc -- number of parameters in pv
  43. **        pv -- pv [0] == DESTPROT destroy permission
  44. **                     == DESTINTEG destroy integrity constraint
  45. **                pv [1]    relation from which to destroy constraint
  46. **                pv [2] == if (pc != 2) relation from which to delete
  47. **                         constraints
  48. **                pv[3] ... pv[pc - 1] == id of constraint
  49. **
  50. **    Returns:
  51. **        0
  52. **
  53. **    Side Effects:
  54. **        destroys constraints. Involves activity on catalogs 'relation',
  55. **        protect, integrities, and tree.
  56. **
  57. **    Trace Flags:
  58. **        43, 0
  59. */
  60.  
  61. dest_const(pc, pv)
  62. int    pc;
  63. PARM    pv[];
  64. {
  65.     DESC            d;
  66.     register int        i;
  67.     int            mode;
  68.     extern struct admin    Admin;
  69.  
  70. #    ifdef xZTR1
  71.     if (tTf(43, 0))
  72.     {
  73.         printf("dest_const: ");
  74.         prvect(pc, pv);
  75.     }
  76. #    endif
  77.  
  78.     if (!(Admin.adhdr.adflags & A_QRYMOD))
  79.         return (0);
  80.     i = openr(&d, OR_RELTID, pv[1].pv_val.pv_str);
  81.     if (i < 0)
  82.         syserr("dest_const: openr(%s) %d", pv[1].pv_val.pv_str, i);
  83.  
  84.     if (i == 1 || !bequal(Usercode, d.reldum.relowner, UCODE_SZ))
  85.     {
  86.         error(RELNOEXIST, pv[1].pv_val.pv_str, 0);
  87.         return (0);
  88.     }
  89.  
  90.     mode = atoi(pv[0].pv_val.pv_str);
  91.     if (mode == DESTPROT)
  92.         dest_prot(&d, &pv[2]);
  93.     else if (mode == DESTINTEG)
  94.         dest_integ(&d, &pv[2]);
  95.     else
  96.         syserr("dest_const: bad mode %d", mode);
  97.     return (0);
  98. }
  99. /*
  100. **  DEST_INTEG -- directs destruction of integrity constraints
  101. **
  102. **    Parameters:
  103. **        desc -- descriptor for relation
  104. **        intv -- PV_EOF terminated list of id strings, if first element
  105. **                is PV_EOF means "all"
  106. **
  107. **    Returns:
  108. **        none
  109. **
  110. **    Side Effects:
  111. **        deletes integrity constraint. Activity on 'relation', integrities,
  112. **        and tree.
  113. */
  114.  
  115. dest_integ(d, intv)
  116. register DESC    *d;
  117. PARM        intv[];
  118. {
  119.     extern DESC        Intdes;
  120.     struct integrity    tuple, key;
  121.     struct tree        tkey;
  122.     register        i, j;
  123.     int            tree_const();
  124.     int            int_inttree();
  125.  
  126. #    ifdef xZTR1
  127.     if (tTf(43, 1))
  128.         printf("dest_integ((%s, %s)...)\n", d->reldum.relid, d->reldum.relowner);
  129. #    endif
  130.  
  131.     i_cat("integrities", &Intdes, &key, d->reldum.relid, INTRELID,
  132.     d->reldum.relowner, INTRELOWNER, mdINTEG, &tkey);
  133.  
  134.     if (intv[0].pv_type == PV_EOF)
  135.     {
  136.         /* destroy integrity 'relation' ALL */
  137.         if (!(d->reldum.relstat & S_INTEG))
  138.             return (0);
  139.         del_all(d, &Intdes, &key, &tuple, &tkey, S_INTEG,
  140.         tree_const, int_inttree);
  141.         return (0);
  142.     }
  143.     /* destroy integrity 'relation' int {, int} */
  144.     for (i = 0; intv[i].pv_type != PV_EOF; i++)
  145.         del_int(&Intdes, &key, &tuple, &tkey, intv[i].pv_val.pv_str, INTTREE, 
  146.         tree_const, int_inttree);
  147.  
  148.     /* rescan to output error messages */
  149.     for (j = 0; j < i; j++)
  150.         if (*(intv[j].pv_val.pv_str))
  151.             error(BADINTEG, intv[j].pv_val.pv_str, 0);
  152.  
  153.     /* finally, check that there are still integrity constraints
  154.     ** on the relation, if not must reset the S_INTEG bit in the relation
  155.     ** relation tuple for that relation.
  156.     */
  157.     chk_const(d, &Intdes, &key, &tuple, d->reldum.relid, INTRELID, d->reldum.relowner,
  158.     INTRELOWNER, S_INTEG);
  159. }
  160. /*
  161. **  DEST_PROT -- directs destruction of protection constraints
  162. **
  163. **    Parameters:
  164. **        desc -- descriptor for relation
  165. **        intv -- PV_EOF terminated list of id strings, if first element
  166. **                is PV_EOF means "all"
  167. **
  168. **    Returns:
  169. **        none
  170. **
  171. **    Side Effects:
  172. **        deletes protection constraint. Activity on 'relation', 
  173. **        protect, and tree.
  174. **
  175. **    Trace Flags:
  176. **        43, 2
  177. */
  178.  
  179.  
  180. dest_prot(d, intv)
  181. register DESC    *d;
  182. PARM        intv[];
  183. {
  184.     extern DESC    Prodes;
  185.     struct protect    tuple, key;
  186.     struct tree    tkey;
  187.     register    i, j;
  188.     int        propermid;
  189.     int        prot_protree();
  190.     int        tree_prot();
  191.  
  192. #    ifdef xZTR1
  193.     if (tTf(43, 2))
  194.         printf("dest_prot((%s, %s)...)\n", d->reldum.relid, d->reldum.relowner);
  195. #    endif
  196.  
  197.     i_cat("protect", &Prodes, &key, d->reldum.relid, PRORELID, d->reldum.relowner,
  198.     PRORELOWN, mdPROT, &tkey);
  199.  
  200.     if (intv[0].pv_type == PV_EOF)
  201.     {
  202.         /* destroy permit 'relation' ALL */
  203.         if (!(d->reldum.relstat & S_PROTRET) || !(d->reldum.relstat & S_PROTALL))
  204.             r_relstat(d, S_PROTRET | S_PROTALL, 1);
  205.         if (!(d->reldum.relstat & S_PROTUPS))
  206.             return (0);
  207.         del_all(d, &Prodes, &key, &tuple, &tkey, S_PROTUPS,
  208.         tree_prot, prot_protree);
  209.         return (0);
  210.     }
  211.     /* destroy permit 'relation' int {, int} */
  212.     for (i = 0; intv[i].pv_type != PV_EOF; i++)
  213.     {
  214.         propermid = atoi(intv[i].pv_val.pv_str);
  215.         if (propermid == 0)
  216.         {
  217.             if (!(d->reldum.relstat & S_PROTALL))
  218.             {
  219.                 r_relstat(d, S_PROTALL, 1);
  220.                 intv[i].pv_val.pv_str = 0;
  221.             }
  222.             continue;
  223.         }
  224.         else if (propermid == 1)
  225.         {
  226.             if (!(d->reldum.relstat & S_PROTRET))
  227.             {
  228.                 r_relstat(d, S_PROTRET, 1);
  229.                 intv[i].pv_val.pv_str = 0;
  230.             }
  231.             continue;
  232.         }
  233.         del_int(&Prodes, &key, &tuple, &tkey, intv[i].pv_val.pv_str, PROPERMID, 
  234.         tree_prot, prot_protree);
  235.     }
  236.     /* rescan to output error messages */
  237.     for (j = 0; j < i; j++)
  238.         if (intv[j].pv_val.pv_str && intv[j].pv_val.pv_str[0] )
  239.             error(BADPROT, intv[j].pv_val.pv_str, 0);
  240.  
  241.     /* finally, check that there are still permissions
  242.     ** on the relation, if not must reset the S_PROTUPS bit in the relation
  243.     ** relation tuple for that relation's relstat.
  244.     */
  245.     chk_const(d, &Prodes, &key, &tuple, d->reldum.relid, PRORELID,
  246.     d->reldum.relowner, PRORELOWN, S_PROTUPS);
  247. }
  248. /*
  249. **  I_CAT -- prepare catalogs for deletin of constraint
  250. **
  251. **    Initializes treerelid, treeowner, and treetype fields
  252. **    of tree key. Also relation id and owner fields of
  253. **    appropriate catalog c_desc, with key 'key'.
  254. **
  255. **    Parameters:
  256. **        c_name -- name of catalog for opencatalog
  257. **        c_desc -- descriptor of catalog
  258. **        key -- key for catalog
  259. **        relid -- relation.relid for relation to be de-constrained
  260. **        id_attno -- attno of relid in constraint catalog c_desc
  261. **        relowner -- relation.relowner for rel to be de-constrained
  262. **        own_attno -- attno of owner in constrain catalog
  263. **        type -- treetype for tree tuple (depends on catalog)
  264. **        tkey -- key for tree catalog
  265. **
  266. **    Returns:
  267. **        none
  268. **
  269. **    Side Effects:
  270. **        opencatalogs the constraint catalog c_desc, and the "tree" rel
  271. **        for READ/WRITE. Sets keys.
  272. **
  273. **    Trace Flags:
  274. **        43, 3
  275. */
  276.  
  277. i_cat(c_name, c_desc, key, relid, id_attno, relowner, own_attno, type, tkey)
  278. char        *c_name;
  279. DESC        *c_desc;
  280. char        *key;
  281. char        *relid;
  282. int        id_attno;
  283. char        *relowner;
  284. int        own_attno;
  285. int        type;
  286. struct tree    *tkey;
  287. {
  288.     extern DESC    Treedes;
  289.     char        realtype;
  290.  
  291. #    ifdef xZTR1
  292.     if (tTf(43, 3))
  293.         printf("i_cat(c_name \"%s\", relid %s id_attno %d relowner %s own_attno %d type %d)\n",
  294.         c_name, relid, id_attno, relowner, own_attno, type);
  295. #    endif
  296.  
  297.     realtype = type;
  298.     opencatalog("tree", OR_WRITE);
  299.     setkey(&Treedes, tkey, relid, TREERELID);
  300.     setkey(&Treedes, tkey, relowner, TREEOWNER);
  301.     setkey(&Treedes, tkey, &realtype, TREETYPE);
  302.     opencatalog(c_name, OR_WRITE);
  303.     clearkeys(c_desc);
  304.     setkey(c_desc, key, relid, id_attno);
  305.     setkey(c_desc, key, relowner, own_attno);
  306. }
  307. /*
  308. **  DEL_ALL -- delete all constraints for a given relation
  309. **
  310. **    Deletes all constraints of a given type given by a constraint
  311. **    catalog 'c_desc'. Note that Protection constraints 0 & 1, given
  312. **    by relation.relstat field are not deleted here.
  313. **
  314. **    Parameters:
  315. **        r_desc -- descriptor for relation to de-constrain (for
  316. **            r_relstat)
  317. **        c_desc -- constraint catalog descriptor
  318. **        key -- c_desc's key
  319. **        tuple -- c_desc's tuple (needed because sizeof tuple is not
  320. **            known here, so must be allocated beforehand)
  321. **        tkey -- tree key with TREERELID and TREERELOWNER setkeyed
  322. **        bit -- bits in relstat to reset after deleting all constraints
  323. **        tree_pred -- called with constraint tuple to determine
  324. **            wether a tree tuple is present or not (as can happen
  325. **            for protect catalog)
  326. **        tree_field -- should return the treeid from tuple
  327. **
  328. **    Returns:
  329. **        none
  330. **
  331. **    Side Effects:
  332. **        tree and constraint catalog activity
  333. **
  334. **    Requires:
  335. **        del_tree()
  336. **        r_relstat()
  337. **
  338. **    Called By:
  339. **        dest_????
  340. **
  341. **    Trace Flags:
  342. **        43, 4
  343. **
  344. **    Syserrs:
  345. **        bad find, get, delete, flush_rel
  346. **
  347. **    History:
  348. **        1/10/79 -- (marc) written
  349. */
  350.  
  351. del_all(r_desc, c_desc, key, tuple, tkey, bit, tree_pred, tree_field)
  352. DESC        *r_desc;
  353. DESC        *c_desc;
  354. char        *key;
  355. char        *tuple;
  356. struct tree    *tkey;
  357. int        bit;
  358. int        (*tree_pred)();
  359. int        (*tree_field)();
  360. {
  361.     TID        lotid, hitid;
  362.     register int    i;
  363.  
  364. #    ifdef xZTR1
  365.     if (tTf(43, 4))
  366.         printf("del_all(bit=0%o)\n", bit);
  367. #    endif
  368.  
  369.     if (i = find(c_desc, EXACTKEY, &lotid, &hitid, key))
  370.         syserr("del_all: find %d", i);
  371.     while (!(i = get(c_desc, &lotid, &hitid, tuple, TRUE)))
  372.     {
  373.         if (!kcompare(c_desc, tuple, key))
  374.         {
  375.             /* for each constraint of for a relation */
  376.             if (i = delete(c_desc, &lotid))
  377.                 syserr("del_all: delete %d", i);
  378.             /* for crash recovery */
  379.             if (i = flush_rel(c_desc, FALSE))
  380.                 syserr("del_all: flush_rel %d", i);
  381.             /* if there is a tree tuple, destroy it */
  382.             if ((*tree_pred)(tuple))
  383.                 del_tree(tkey, (*tree_field)(tuple));
  384.         }
  385.     }
  386.     if (i != 1)
  387.         syserr("del_all: get %d", i);
  388.     /* turn off bit in relstat field */
  389.     r_relstat(r_desc, bit, 0);
  390. }
  391. /*
  392. **  DEL_INT -- delete from a constraint catalog a constraint
  393. **
  394. **    Parameters:
  395. **        c_desc -- catalog descriptor
  396. **        key -- catalog key
  397. **        tuple -- catalog tuple (needed because tuple size unknown here)
  398. **        tkey -- tree key with TREERELID and TREERELOWNER setkeyed
  399. **        constid -- integer constraint id in string form
  400. **        constattno -- attno of comstraint number in c_desc
  401. **        tree_pred -- predicate on existence of tree tuple 
  402. **        tree_field -- returns treeid from constrain tuple
  403. **
  404. **    Returns:
  405. **        none
  406. **
  407. **    Side Effects:
  408. **        constraint and tree catalog activity.
  409. **        *constid set to 0 if constraint id exists.
  410. **
  411. **    Requires:
  412. **        del_tree()
  413. **
  414. **    Called By:
  415. **        dest_????
  416. **
  417. **    Trace Flags:
  418. **        43, 5
  419. **
  420. **    Syserrs:
  421. **        bad atoi (parser error), getequal, delete, flush_rel
  422. **
  423. **    History:
  424. **        1/10/79 -- (marc) written
  425. */
  426.  
  427. del_int(c_desc, key, tuple, tkey, constid, constattno, tree_pred, tree_field)
  428. DESC        *c_desc;
  429. char        *key;
  430. char        *tuple;
  431. struct tree    *tkey;
  432. char        *constid;
  433. int        constattno;
  434. int        (*tree_pred)();
  435. int        (*tree_field)();
  436. {
  437.     TID        tid;
  438.     register int    i;
  439.     short        constnum;
  440.  
  441. #    ifdef xZTR1
  442.     if (tTf(43, 5))
  443.         printf("del_int(constid=%s, constattno=%d)\n", 
  444.          constid, constattno);
  445. #    endif
  446.  
  447.     constnum = atoi(constid);
  448.     setkey(c_desc, key, &constnum, constattno);
  449.     if (!(i = getequal(c_desc, key, tuple, &tid)))
  450.     {
  451.         if (i = delete(c_desc, &tid))
  452.             syserr("del_int(%d) %d", constid, i);
  453.         if ((*tree_pred)(tuple))
  454.             del_tree(tkey, (*tree_field)(tuple));
  455.         *constid = '\0';
  456.         return;
  457.     }
  458.     else if (i != 1)
  459.         syserr("dest_int: getequal %d", i);
  460.     /* bad constnum */
  461. }
  462. /*
  463. **  DEST_TREE -- destroy a tree tuple with for a given treeid
  464. **
  465. **    Deletes all tuples from tree with 'treeid' and previously set
  466. **    keys.
  467. **
  468. **    Parameters:
  469. **        key -- tre key
  470. **        treeid -- integer treeid
  471. **
  472. **    Returns:
  473. **        none
  474. **
  475. **    Side Effects:
  476. **        tree activity
  477. **
  478. **    Trace Flags:
  479. **        43, 6
  480. */
  481.  
  482. del_tree(key, treeid)
  483. struct tree    *key;
  484. int        treeid;
  485. {
  486.     struct tree    tuple;
  487.     TID        lotid, hitid;
  488.     register int    i;
  489.     register int    flag;
  490.     short        realid;
  491.     extern DESC    Treedes;
  492.  
  493. #    ifdef xZTR1
  494.     if (tTf(43, 6))
  495.         printf("del_tree(treeid=%d)\n", treeid);
  496. #    endif
  497.  
  498.     realid = treeid;
  499.     setkey(&Treedes, key, &realid, TREEID);
  500.     if (i = find(&Treedes, EXACTKEY, &lotid, &hitid, key))
  501.         syserr("del_tree: bad find %d treeid %d", i, treeid);
  502.     flag = 0;
  503.     while (!(i = get(&Treedes, &lotid, &hitid, &tuple, TRUE)))
  504.     {
  505.         if (!kcompare(&Treedes, &tuple, key))
  506.         {
  507.             if (i = delete(&Treedes, &lotid))
  508.                 syserr("del_tree: delete treeid %d %d", treeid, i);
  509.             if (!flag)
  510.                 flag++;
  511.         }
  512.     }
  513.     if (i != 1)
  514.         syserr("del_tree: bad get %d", i);
  515.     if (!flag)
  516.         syserr("del_tree: no tuples qualified treeid %d", treeid);
  517.     if (i = flush_rel(&Treedes, FALSE))
  518.         syserr("del_tree: flush_rel(&Treedes) %d", i);
  519. }
  520. /*
  521. **  CHK_CONST -- check constraint catlg for tuples for a rel, and reset relatin.relstat
  522. **
  523. **    Parameters:
  524. **        r_desc -- reon desc for de-constrained relation
  525. **        c_desc -- catalog desc
  526. **        key -- catalog key (here unknown size)
  527. **        tuple -- " tuple space " " " " "
  528. **        relid -- relation name
  529. **        id_attno -- attno of relid
  530. **        relowner -- relation owner
  531. **        own_attno -- relowner attno
  532. **        bit -- bits to reset in relstat if there are no constraints left
  533. **
  534. **    Returns:
  535. **        none
  536. **
  537. **    Side Effects:
  538. **        reads catalog, maybe changes relstat field of relation
  539. **        relations's r_desc tuple
  540. **
  541. **    Trace Flags:
  542. **        43, 7
  543. */
  544.  
  545. chk_const(r_desc, c_desc, key, tuple, relid, id_attno, relowner, own_attno, bit)
  546. DESC    *r_desc;
  547. DESC    *c_desc;
  548. char    *key;
  549. char    *tuple;
  550. char    *relid;
  551. int    id_attno;
  552. char    *relowner;
  553. int    own_attno;
  554. int    bit;
  555. {
  556.     TID        tid;
  557.     register int    i;
  558.  
  559.  
  560. #    ifdef xZTR1
  561.     if (tTf(43, 7))
  562.         printf("chk_const: relid %s id_attno %d relowner %s own_attno %d bit 0%o)\n",
  563.         relid, id_attno, relowner, own_attno, bit);
  564. #    endif
  565.  
  566.     clearkeys(c_desc);
  567.     setkey(c_desc, key, relid, id_attno);
  568.     setkey(c_desc, key, relowner, own_attno);
  569.     if ((i = getequal(c_desc, key, tuple, &tid)) == 1)
  570.         r_relstat(r_desc, bit, 0);
  571.     else if (i < 0)
  572.         syserr("chk_const: getequal %d", i);
  573. }
  574. /*
  575. **  R_RELSTAT -- set or reset bits in the relation.relstat field
  576. **
  577. **    Does the above for relation described by desc.
  578. **
  579. **    Parameters:
  580. **        d -- relation to have relation.relstat field changed
  581. **        bit -- bits to set or reset
  582. **        action -- 0 reset, 1 set
  583. **
  584. **    Returns:
  585. **        none
  586. **
  587. **    Side Effects:
  588. **        relation is opened for READ/WRITE, relstat changed
  589. **
  590. **    Trace Flags:
  591. **        43, 8
  592. */
  593.  
  594.  
  595. r_relstat(d, bit, action)
  596. register DESC    *d;
  597. int        bit;
  598. int        action;
  599. {
  600.     struct relation    tuple, key;
  601.     TID        tid;
  602.     register int    i;
  603.     extern DESC    Reldes;
  604.  
  605. #    ifdef xZTR1
  606.     if (tTf(43, 8))
  607.         printf("r_relstat(bit=0%o, action %d)\n",
  608.         bit, action);
  609. #    endif
  610.  
  611.     opencatalog("relation", OR_WRITE);
  612.     clearkeys(&Reldes);
  613.     setkey(&Reldes, &key, d->reldum.relid, RELID);
  614.     setkey(&Reldes, &key, d->reldum.relowner, RELOWNER);
  615.     if (i = getequal(&Reldes, &key, &tuple, &tid))
  616.         syserr("r_relstat: getequal %s, %s, %d", d->reldum.relid,
  617.         d->reldum.relowner, i);
  618.     if (action)
  619.     {
  620.         if (tuple.relstat == (i = tuple.relstat | bit))
  621.             return;
  622.         tuple.relstat = i;
  623.     }
  624.     else
  625.     {
  626.         if (tuple.relstat == (i = tuple.relstat & ~bit))
  627.             return;
  628.         tuple.relstat = i;
  629.     }
  630.     if ((i = replace(&Reldes, &tid, &tuple, 0)) < 0 || i == 2)
  631.         syserr("r_relstat: replace %d", i);
  632.     if (i = flush_rel(&Reldes, FALSE))
  633.         syserr("r_relstat: flush_rel(&Reldes) %d", i);
  634. }
  635. /*
  636. **  TREE_CONST -- True predicate
  637. **
  638. **    Called indirectly by routines wishing to know if
  639. **    a integrity constraint has an associated tree tuple.
  640. **    As this is always the case, returns TRUE always.
  641. **
  642. **    Parameters:
  643. **        i -- integrity tuple
  644. **
  645. **    Returns:
  646. **        TRUE
  647. **
  648. **    Side Effects:
  649. **        none
  650. **
  651. **    Trace Flags:
  652. **        43, 9
  653. */
  654.  
  655. tree_const(i)
  656. struct integrity    *i;
  657. {
  658. #    ifdef xZTR1
  659.     if (tTf(43, 9))
  660.         printf("tree_const()\n");
  661. #    endif
  662.  
  663.     return (TRUE);
  664. }
  665. /*
  666. **  TREE_PROT -- Protection tuple tree predicate
  667. **
  668. **    Called indirectly by routines wishing to know if
  669. **    a protection constraint has an associated tree tuple.
  670. **
  671. **    Parameters:
  672. **        p -- protect tuple
  673. **
  674. **    Returns:
  675. **        TRUE -- if p->protree != -1
  676. **        FLASE -- otherwise
  677. **
  678. **    Side Effects:
  679. **        none
  680. **
  681. **    Trace Flags:
  682. **        43, 9
  683. */
  684.  
  685. tree_prot(p)
  686. struct protect    *p;
  687. {
  688. #    ifdef xZTR1
  689.     if (tTf(43, 9))
  690.         printf("tree_prot(p->protree=%d)\n", p->protree);
  691. #    endif
  692.  
  693.     if (p->protree == -1)
  694.         return (FALSE);
  695.     else
  696.         return (TRUE);
  697. }
  698. /*
  699. **  PROT_PROTREE -- get protree field of a protection tuple
  700. **
  701. **    Parameters:
  702. **        p -- protect tuple
  703. **
  704. **    Returns:
  705. **        p->protree
  706. **
  707. **    Side Effects:
  708. **        none
  709. **
  710. **    Trace Flags:
  711. **        43, 9
  712. */
  713.  
  714. prot_protree(p)
  715. struct protect    *p;
  716. {
  717. #    ifdef xZTR1
  718.     if (tTf(43, 9))
  719.         printf("prot_protree(protree=%d)\n", p->protree);
  720. #    endif
  721.  
  722.     return (p->protree);
  723. }
  724. /*
  725. **  INT_INTTREE -- get inttree field of a integrity tuple
  726. **
  727. **    Parameters:
  728. **        i -- integrity tuple
  729. **
  730. **    Returns:
  731. **        i->inttree
  732. **
  733. **    Side Effects:
  734. **        none
  735. **
  736. **    Trace Flags:
  737. **        43, 9
  738. */
  739.  
  740. int_inttree(i)
  741. struct integrity    *i;
  742. {
  743. #    ifdef xZTR1
  744.     if (tTf(43, 9))
  745.         printf("int_inttree(inttree=%d)\n", i->inttree);
  746. #    endif
  747.  
  748.     return (i->inttree);
  749. }
  750.